home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #1 / Ham Radio 2000.iso / ham2000 / packet / p_aa4re / bb212src / bbsrtblo.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1990-10-26  |  9.4 KB  |  265 lines
  1. (*===========================================================================*)
  2. (* Procedure to send/receive things to the tnc in block                      *)
  3. (*                                                                           *)
  4. (*   Copyright 1988, 1989, 1990 by H. Roy Engehausen.  All rights reserved.  *)
  5. (*   This software may be freely distributed and used, but it may not        *)
  6. (*   under any circumstances be sold by anyone other than the author.        *)
  7. (*   It may be distributed by a commercial company as long as it is          *)
  8. (*   for no cost.                                                            *)
  9. (*                                                                           *)
  10. (*===========================================================================*)
  11.  
  12. PROCEDURE send_block_mode;
  13.  
  14.   TYPE
  15.     over_array = ARRAY[1..512] OF BYTE;
  16.  
  17.   VAR
  18.  
  19.     byte_array     : ^over_array;
  20.     byte_count     : WORD;
  21.     set_dx         : BYTE;
  22.     times_up       : LONGINT;
  23.     tnc_registers  : REGISTERS;
  24.  
  25.   BEGIN;
  26.  
  27. stack_depth;
  28.  
  29. {$IFDEF DEBUG_BLOCK}
  30.   WINDOW(1,1,80,25);
  31. {$ENDIF}
  32.  
  33.     (*-----------------------------------------------------------------------*)
  34.     (* Save the COM number for later use                                     *)
  35.     (*-----------------------------------------------------------------------*)
  36.  
  37.     set_dx := active_port^.com_number - 1;
  38.  
  39.     (*-----------------------------------------------------------------------*)
  40.     (* Ok.  Get addressing for transmit                                      *)
  41.     (*-----------------------------------------------------------------------*)
  42.  
  43.     WITH active_tcb^.tnc_htt^, tnc_registers DO
  44.       BEGIN;
  45.  
  46.         (*-------------------------------------------------------------------*)
  47.         (* See if junk around?                                               *)
  48.         (*-------------------------------------------------------------------*)
  49.  
  50.         AX := $0300;
  51.         DX := set_dx;
  52.  
  53.         signal_place^ := $0200 + LO(signal_place^);
  54.  
  55.         INTR(tnc_interrupt, tnc_registers);
  56.  
  57.         signal_place^ := $F800 + LO(signal_place^);
  58.  
  59.         AH := AH AND lsr_8250_dr;
  60.         IF AH <> 0 THEN
  61.           window_write_critical('Garbage from TNC -- '
  62.                                                     + active_tcb^.port_chan_s
  63.                                                     + ' -- ',
  64.                                  garbage_collect_tnc);
  65.  
  66.         (*-------------------------------------------------------------------*)
  67.         (* Transmit it!                                                      *)
  68.         (*-------------------------------------------------------------------*)
  69.  
  70.         AX := $0A00;
  71.         CX := data_count + 4;
  72.         DX := set_dx;
  73.         DI := OFS(channel);
  74.         ES := SEG(channel);
  75.  
  76. {$IFDEF DEBUG_BLOCK}
  77.     WRITELN('Send =', cx);
  78.     WRITELN('Off=', di);
  79.     byte_array := PTR(ES,DI);
  80.     WRITE  (ORD(byte_array^[1]),',');
  81.     WRITE  (ORD(byte_array^[2]),',');
  82.     WRITE  (ORD(byte_array^[3]),',');
  83.     WRITE  (ORD(byte_array^[4]),',');
  84.     WRITE  (ORD(byte_array^[5]),',');
  85.     WRITE  (ORD(byte_array^[6]),',');
  86.     WRITE  (ORD(byte_array^[7]),',');
  87.     WRITE  (ORD(byte_array^[8]),',');
  88.     WRITELN(ORD(byte_array^[9]),',');
  89. {$ENDIF}
  90.  
  91.         signal_place^ := $0100 + LO(signal_place^);
  92.  
  93.         INTR(tnc_interrupt, tnc_registers);
  94.  
  95.         signal_place^ := $7800 + LO(signal_place^);
  96.  
  97. {$IFDEF DEBUG_BLOCK}
  98.     WRITELN('Return cx=', cx);
  99.     WRITELN('Off=', di);
  100. {$ENDIF}
  101.  
  102.       END;
  103.  
  104.     (*-----------------------------------------------------------------------*)
  105.     (* If this is master task then time check                                *)
  106.     (*-----------------------------------------------------------------------*)
  107.  
  108.     IF master_thread THEN
  109.       time_check;
  110.  
  111.     (*-----------------------------------------------------------------------*)
  112.     (* If QRES then leave now.                                               *)
  113.     (*-----------------------------------------------------------------------*)
  114.  
  115.     IF qres_resp THEN
  116.       EXIT;
  117.  
  118.     (*-----------------------------------------------------------------------*)
  119.     (* Ok.  Get addressing for receive                                       *)
  120.     (*-----------------------------------------------------------------------*)
  121.  
  122.     WITH active_tcb^.tnc_tth^, tnc_registers DO
  123.       BEGIN;
  124.  
  125.         (*-------------------------------------------------------------------*)
  126.         (* Prep the counter and timeouts                                     *)
  127.         (*-------------------------------------------------------------------*)
  128.  
  129.         times_up := up_time + time_out_value;
  130.  
  131.         byte_count := 0;
  132.  
  133.         (*-------------------------------------------------------------------*)
  134.         (* Initialize                                                        *)
  135.         (*-------------------------------------------------------------------*)
  136.  
  137.         CX := SIZEOF(tnc_to_host);
  138.         DI := OFS(channel);
  139.         ES := SEG(channel);
  140.  
  141.         byte_array := @channel;
  142.         byte_count := 0;
  143.  
  144.         (*-------------------------------------------------------------------*)
  145.         (* Loop reading the data                                             *)
  146.         (*-------------------------------------------------------------------*)
  147.  
  148.         WHILE TRUE DO
  149.           BEGIN;
  150.  
  151.             task_switch;
  152.  
  153.             (*---------------------------------------------------------------*)
  154.             (* Receive it                                                    *)
  155.             (*---------------------------------------------------------------*)
  156.  
  157.             AX := $0B00;
  158.             CX := SIZEOF(tnc_to_host) - byte_count;
  159.             DX := set_dx;
  160.  
  161. {$IFDEF DEBUG_BLOCK}
  162.     WRITELN('BCX=', cx);
  163.     WRITELN('BDI=', di);
  164.     WRITELN('BES=', es);
  165. {$ENDIF}
  166.  
  167.             signal_place^ := $0200 + LO(signal_place^);
  168.  
  169.             INTR(tnc_interrupt, tnc_registers);
  170.  
  171.             signal_place^ := $F800 + LO(signal_place^);
  172.  
  173.             byte_count := byte_count + CX;
  174.  
  175. {$IFDEF DEBUG_BLOCK}
  176.     WRITELN('ACX=', cx);
  177.     WRITELN('ADI=', di);
  178.     WRITELN('AES=', es);
  179.     WRITELN('byte_count=', byte_count);
  180. {$ENDIF}
  181.  
  182.             AH := AH AND lsr_8250_or;
  183.             IF AH <> 0 THEN
  184.               BEGIN;
  185.                 window_write_critical_i('Overrun block loop -- '
  186.                                                      + active_tcb^.port_chan_s
  187.                                                      + ' -- Count = ',
  188.                                                       byte_count);
  189.                 IF byte_count <= 5 THEN
  190.                   WHILE byte_count <= 10 DO
  191.                     BEGIN;
  192.                       INC(byte_count);
  193.                       byte_array^[byte_count] := $0;
  194.                     END;
  195.                 EXIT;
  196.               END;
  197.  
  198.             IF master_thread THEN
  199.               time_check;
  200.  
  201.             IF (times_up < up_time) AND (CX = 0) THEN
  202.               BEGIN;
  203.                 window_write_critical_i('Timeout block loop -- '
  204.                                                      + active_tcb^.port_chan_s
  205.                                                      + ' -- Count = ',
  206.                                                       byte_count);
  207.                 IF byte_count <= 5 THEN
  208.                   WHILE byte_count <= 10 DO
  209.                     BEGIN;
  210.                       INC(byte_count);
  211.                       byte_array^[byte_count] := $0;
  212.                     END;
  213.  
  214.                 EXIT;
  215.               END;
  216.  
  217.             IF byte_count >= 2 THEN
  218.               BEGIN;
  219.  
  220. {$IFDEF DEBUG_BLOCK}
  221.     WRITELN('Code=', tnc_code);
  222.     WRITELN('lastchar=', ORD(byte_array^[byte_count]));
  223. {$ENDIF}
  224.  
  225.                 IF tnc_code = 0 THEN EXIT;
  226.  
  227.                 (*-----------------------------------------------------------*)
  228.                 (* If this is a null terminated response and it is a null,   *)
  229.                 (* then we must be done                                      *)
  230.                 (*-----------------------------------------------------------*)
  231.  
  232.                 IF (byte_array^[byte_count] = 0) AND (tnc_code < 6) THEN
  233.                   EXIT;
  234.  
  235.                 (*-----------------------------------------------------------*)
  236.                 (* Watch for weirdos                                         *)
  237.                 (*-----------------------------------------------------------*)
  238.  
  239.                 IF byte_count > 260 THEN
  240.                   BEGIN;
  241.                     WRITELN;
  242.                     WRITELN('Ser I/O Crash');
  243.                     WRITELN('Byte cnt = ', byte_count);
  244.                     WRITELN('AL = ', AL);
  245.                     WRITELN('Type = ', tnc_code);
  246.                     HALT;
  247.                   END;
  248.  
  249.                 (*-----------------------------------------------------------*)
  250.                 (* If this is a data count response and the count is correct *)
  251.                 (* then we must be done                                      *)
  252.                 (*-----------------------------------------------------------*)
  253.  
  254.                 IF (byte_count >= (data67_count + 4)) AND (tnc_code >= 6)
  255.                                                       AND (byte_count > 2) THEN
  256.                   EXIT;
  257.  
  258.               END;
  259.  
  260.           END; (*----- End loop for receiving the response ------------------*)
  261.  
  262.       END;
  263.  
  264.   END;
  265.